/*
 * Copyright (C) 2008 ZXing authors
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.google.zxing.client.android;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLEncoder;
import java.text.DateFormat;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.EnumSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ExecutionException;
import org.apache.http.HttpStatus;
import org.apache.http.StatusLine;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.impl.client.DefaultHttpClient;
import android.app.Activity;
import android.app.AlertDialog;
import android.app.Dialog;
import android.app.ProgressDialog;
import android.content.ContentValues;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.SharedPreferences;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.net.Uri;
import android.os.AsyncTask;
import android.os.Bundle;
import android.os.Environment;
import android.os.Handler;
import android.os.Message;
import android.preference.PreferenceManager;
import android.text.ClipboardManager;
import android.util.Log;
import android.util.TypedValue;
import android.view.Gravity;
import android.view.KeyEvent;
import android.view.LayoutInflater;
import android.view.Menu;
import android.view.MenuInflater;
import android.view.MenuItem;
import android.view.MotionEvent;
import android.view.SurfaceHolder;
import android.view.SurfaceView;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.ViewGroup;
import android.view.Window;
import android.view.WindowManager;
import android.webkit.WebView;
import android.webkit.WebViewClient;
import android.widget.ArrayAdapter;
import android.widget.Button;
import android.widget.EditText;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.RelativeLayout;
import android.widget.TextView;
import android.widget.Toast;
import com.google.screen.Authentication;
import com.google.screen.Contact;
import com.google.screen.Control;
import com.google.screen.DBAdapter;
import com.google.screen.FAQs;
import com.google.screen.History;
import com.google.screen.Login;
import com.google.screen.Control.Logout;
import com.google.zxing.BarcodeFormat;
import com.google.zxing.Result;
import com.google.zxing.ResultMetadataType;
import com.google.zxing.ResultPoint;
import com.google.zxing.client.android.camera.CameraManager;
import com.google.zxing.client.android.history.HistoryItem;
import com.google.zxing.client.android.history.HistoryManager;
import com.google.zxing.client.android.result.ContentQuestions;
import com.google.zxing.client.android.result.Question;
import com.google.zxing.client.android.result.ResultButtonListener;
import com.google.zxing.client.android.result.ResultHandler;
import com.google.zxing.client.android.result.ResultHandlerFactory;
import com.google.zxing.client.android.result.supplement.SupplementalInfoRetriever;

/**
 * This activity opens the camera and does the actual scanning on a background
 * thread. It draws a viewfinder to help the user place the barcode correctly,
 * shows feedback as the image processing is happening, and then overlays the
 * results when a scan is successful.
 * 
 * @author dswitkin@google.com (Daniel Switkin)
 * @author Sean Owen
 */
public final class CaptureActivity extends Activity implements
		SurfaceHolder.Callback {

	private static final String TAG = CaptureActivity.class.getSimpleName();

	private static final long DEFAULT_INTENT_RESULT_DURATION_MS = 1500L;
	private static final long BULK_MODE_SCAN_DELAY_MS = 1000L;

	private static final String PACKAGE_NAME = "com.google.zxing.client.android";
	private static final String PRODUCT_SEARCH_URL_PREFIX = "http://www.google";
	private static final String PRODUCT_SEARCH_URL_SUFFIX = "/m/products/scan";
	private static final String[] ZXING_URLS = {
			"http://zxing.appspot.com/scan", "zxing://scan/" };
	private static final String RETURN_CODE_PLACEHOLDER = "{CODE}";
	private static final String RETURN_URL_PARAM = "ret";
	private static final String RAW_PARAM = "raw";

	public static final int HISTORY_REQUEST_CODE = 0x0000bacc;

	private static final Set<ResultMetadataType> DISPLAYABLE_METADATA_TYPES = EnumSet
			.of(ResultMetadataType.ISSUE_NUMBER,
					ResultMetadataType.SUGGESTED_PRICE,
					ResultMetadataType.ERROR_CORRECTION_LEVEL,
					ResultMetadataType.POSSIBLE_COUNTRY);

	private CameraManager cameraManager;
	private CaptureActivityHandler handler;
	private Result savedResultToShow;
	private ViewfinderView viewfinderView;
	private TextView statusView;
	private View resultView;
	private Result lastResult;
	private boolean hasSurface;
	private boolean copyToClipboard;
	private IntentSource source;
	private String sourceUrl;
	private String returnUrlTemplate;
	private boolean returnRaw;
	private Collection<BarcodeFormat> decodeFormats;
	private String characterSet;
	private HistoryManager historyManager;
	private InactivityTimer inactivityTimer;
	private BeepManager beepManager;

	/******************
	 * Author : Toan Truong Thien Variable : checkBarCodeValuable Date create:
	 * 20-6-2013
	 * ****************/
	private String mStrToken;
	private DBAdapter mDB;
	private Button mBtnCaptureStartScan;
	private ImageView mImgCaptureFrame;
	private SharedPreferences mSharedPref;
	private RelativeLayout mRlayMenu;
	private ImageView mImgMenu;
	private boolean mBlnMenu = false;

	/******************
	 * Author : Khanh Bui Variable : Pop up Result elements Date create:
	 * 25-1-2013
	 * ****************/
	// private RelativeLayout rltPopUpResult;

	private ImageView imgResult;

	private TextView txtTitle;

	private Button btnExitDialog;

	private Button btnPrevious;

	private ArrayList<ContentQuestions> arrlstContQues;

	private int isValid;

	private View popupResult;

	private Button btnNext;

	private String strUrl;

	private Button btnURL;

	private WebView webURLContent;

	private Button btnBack;

	public long dateModified;

	private SharedPreferences sharedPref;

	private long lastDateModified;

	private Boolean isUpdateButton = false;

	private String strDownloadPDF;

	/******************/

	ViewfinderView getViewfinderView() {
		return viewfinderView;
	}

	public Handler getHandler() {
		return handler;
	}

	CameraManager getCameraManager() {
		return cameraManager;
	}

	@Override
	public void onCreate(Bundle icicle) {
		super.onCreate(icicle);

		Window window = getWindow();
		window.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
		this.requestWindowFeature(Window.FEATURE_NO_TITLE);
		setContentView(R.layout.capture);

		mDB = new DBAdapter(this);
		mDB.open();
		mStrToken = getIntent().getExtras().getString("Token");
		mSharedPref = getSharedPreferences("BarcodePref", Context.MODE_PRIVATE);

		mRlayMenu = (RelativeLayout) findViewById(R.id.rlayCaptureMenu);
		mImgMenu = (ImageView) findViewById(R.id.imgCaptureLogo);

		mImgMenu.setOnClickListener(new View.OnClickListener() {

			@Override
			public void onClick(View v) {
				if (mBlnMenu) {
					mRlayMenu.removeAllViews();
					mRlayMenu.setVisibility(View.GONE);
					mBlnMenu = false;
				} else {
					LayoutInflater inf = (LayoutInflater) getSystemService(Context.LAYOUT_INFLATER_SERVICE);
					View view = inf.inflate(R.layout.menu, null);
					mRlayMenu.addView(view);
					mRlayMenu.setVisibility(View.VISIBLE);
					mBlnMenu = true;
				}
			}
		});

		hasSurface = false;
		historyManager = new HistoryManager(this);
		historyManager.trimHistory();
		inactivityTimer = new InactivityTimer(this);
		beepManager = new BeepManager(this);

		// new getContentXML().execute();

		Log.i("check", "on Create");
		// Initialise attribute for pop-up view
		initialDialogAttribute();

		PreferenceManager.setDefaultValues(this, R.xml.preferences, false);
		showHelpOnFirstLaunch();
	}

	@Override
	protected void onResume() {
		super.onResume();

		// CameraManager must be initialized here, not in onCreate(). This is
		// necessary because we don't
		// want to open the camera driver and measure the screen size if we're
		// going to show the help on
		// first launch. That led to bugs where the scanning rectangle was the
		// wrong size and partially
		// off screen.
		cameraManager = new CameraManager(getApplication());

		viewfinderView = (ViewfinderView) findViewById(R.id.viewfinder_view);
		viewfinderView.setCameraManager(cameraManager);

		resultView = findViewById(R.id.result_view);
		popupResult = findViewById(R.id.rltPopUpResult);
		statusView = (TextView) findViewById(R.id.status_view);

		handler = null;
		lastResult = null;

		resetStatusView();

		SurfaceView surfaceView = (SurfaceView) findViewById(R.id.preview_view);
		SurfaceHolder surfaceHolder = surfaceView.getHolder();
		if (hasSurface) {
			// The activity was paused but not stopped, so the surface still
			// exists. Therefore
			// surfaceCreated() won't be called, so init the camera here.
			initCamera(surfaceHolder);
		} else {
			// Install the callback and wait for surfaceCreated() to init the
			// camera.
			surfaceHolder.addCallback(this);
			surfaceHolder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);
		}

		beepManager.updatePrefs();

		inactivityTimer.onResume();

		Intent intent = getIntent();

		SharedPreferences prefs = PreferenceManager
				.getDefaultSharedPreferences(this);
		copyToClipboard = prefs.getBoolean(
				PreferencesActivity.KEY_COPY_TO_CLIPBOARD, true)
				&& (intent == null || intent.getBooleanExtra(
						Intents.Scan.SAVE_HISTORY, true));

		source = IntentSource.NONE;
		decodeFormats = null;
		characterSet = null;

		if (intent != null) {

			String action = intent.getAction();
			String dataString = intent.getDataString();

			if (Intents.Scan.ACTION.equals(action)) {

				// Scan the formats the intent requested, and return the result
				// to the calling activity.
				source = IntentSource.NATIVE_APP_INTENT;
				decodeFormats = DecodeFormatManager.parseDecodeFormats(intent);

				if (intent.hasExtra(Intents.Scan.WIDTH)
						&& intent.hasExtra(Intents.Scan.HEIGHT)) {
					int width = intent.getIntExtra(Intents.Scan.WIDTH, 0);
					int height = intent.getIntExtra(Intents.Scan.HEIGHT, 0);
					if (width > 0 && height > 0) {
						cameraManager.setManualFramingRect(width, height);
					}
				}

				String customPromptMessage = intent
						.getStringExtra(Intents.Scan.PROMPT_MESSAGE);
				if (customPromptMessage != null) {
					statusView.setText(customPromptMessage);
				}

			} else if (dataString != null
					&& dataString.contains(PRODUCT_SEARCH_URL_PREFIX)
					&& dataString.contains(PRODUCT_SEARCH_URL_SUFFIX)) {

				// Scan only products and send the result to mobile Product
				// Search.
				source = IntentSource.PRODUCT_SEARCH_LINK;
				sourceUrl = dataString;
				decodeFormats = DecodeFormatManager.PRODUCT_FORMATS;

			} else if (isZXingURL(dataString)) {

				// Scan formats requested in query string (all formats if none
				// specified).
				// If a return URL is specified, send the results there.
				// Otherwise, handle it ourselves.
				source = IntentSource.ZXING_LINK;
				sourceUrl = dataString;
				Uri inputUri = Uri.parse(sourceUrl);
				returnUrlTemplate = inputUri
						.getQueryParameter(RETURN_URL_PARAM);
				returnRaw = inputUri.getQueryParameter(RAW_PARAM) != null;
				decodeFormats = DecodeFormatManager
						.parseDecodeFormats(inputUri);

			}

			characterSet = intent.getStringExtra(Intents.Scan.CHARACTER_SET);

		}
	}

	private static boolean isZXingURL(String dataString) {
		if (dataString == null) {
			return false;
		}
		for (String url : ZXING_URLS) {
			if (dataString.startsWith(url)) {
				return true;
			}
		}
		return false;
	}

	@Override
	protected void onPause() {
		if (handler != null) {
			handler.quitSynchronously();
			handler = null;
		}
		inactivityTimer.onPause();
		cameraManager.closeDriver();
		if (!hasSurface) {
			SurfaceView surfaceView = (SurfaceView) findViewById(R.id.preview_view);
			SurfaceHolder surfaceHolder = surfaceView.getHolder();
			surfaceHolder.removeCallback(this);
		}
		super.onPause();
	}

	@Override
	protected void onDestroy() {
		inactivityTimer.shutdown();
		super.onDestroy();
	}

	@Override
	public boolean onKeyDown(int keyCode, KeyEvent event) {
		switch (keyCode) {
		case KeyEvent.KEYCODE_BACK:
			if (source == IntentSource.NATIVE_APP_INTENT) {
				setResult(RESULT_CANCELED);
				finish();
				return true;
			}
			if ((source == IntentSource.NONE || source == IntentSource.ZXING_LINK)
					&& lastResult != null) {
				restartPreviewAfterDelay(0L);
				return true;
			}
			break;
		case KeyEvent.KEYCODE_FOCUS:
		case KeyEvent.KEYCODE_CAMERA:
			// Handle these events so they don't launch the Camera app
			return true;
			// Use volume up/down to turn on light
		case KeyEvent.KEYCODE_VOLUME_DOWN:
			cameraManager.setTorch(false);
			return true;
		case KeyEvent.KEYCODE_VOLUME_UP:
			cameraManager.setTorch(true);
			return true;
		}
		return super.onKeyDown(keyCode, event);
	}

	@Override
	public boolean onCreateOptionsMenu(Menu menu) {
		MenuInflater menuInflater = getMenuInflater();
		menuInflater.inflate(R.menu.capture, menu);
		return super.onCreateOptionsMenu(menu);
	}

	@Override
	public boolean onOptionsItemSelected(MenuItem item) {
		// Intent intent = new Intent(Intent.ACTION_VIEW);
		// intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET);
		// switch (item.getItemId()) {
		// case R.id.menu_share:
		// intent.setClassName(this, ShareActivity.class.getName());
		// startActivity(intent);
		// break;
		// case R.id.menu_history:
		// intent.setClassName(this, HistoryActivity.class.getName());
		// startActivityForResult(intent, HISTORY_REQUEST_CODE);
		// break;
		// case R.id.menu_settings:
		// intent.setClassName(this, PreferencesActivity.class.getName());
		// startActivity(intent);
		// break;
		// case R.id.menu_help:
		// intent.setClassName(this, HelpActivity.class.getName());
		// startActivity(intent);
		// break;
		// default:
		// return super.onOptionsItemSelected(item);
		// }

		switch (item.getItemId()) {
		case R.id.menu_update_database:
			isUpdateButton = true;
			// new getContentXML().execute();

			break;

		default:
			break;
		}
		return true;
	}

	@Override
	public void onActivityResult(int requestCode, int resultCode, Intent intent) {
		if (resultCode == RESULT_OK) {
			if (requestCode == HISTORY_REQUEST_CODE) {
				int itemNumber = intent.getIntExtra(
						Intents.History.ITEM_NUMBER, -1);
				if (itemNumber >= 0) {
					HistoryItem historyItem = historyManager
							.buildHistoryItem(itemNumber);
					decodeOrStoreSavedBitmap(null, historyItem.getResult());
				}
			}
		}
	}

	private void decodeOrStoreSavedBitmap(Bitmap bitmap, Result result) {
		// Bitmap isn't used yet -- will be used soon
		if (handler == null) {
			savedResultToShow = result;
		} else {
			if (result != null) {
				savedResultToShow = result;
			}
			if (savedResultToShow != null) {
				Message message = Message.obtain(handler,
						R.id.decode_succeeded, savedResultToShow);
				handler.sendMessage(message);
			}
			savedResultToShow = null;
		}
	}

	@Override
	public void surfaceCreated(SurfaceHolder holder) {
		if (holder == null) {
			Log.e(TAG,
					"*** WARNING *** surfaceCreated() gave us a null surface!");
		}
		if (!hasSurface) {
			hasSurface = true;
			initCamera(holder);
		}
	}

	@Override
	public void surfaceDestroyed(SurfaceHolder holder) {
		hasSurface = false;
	}

	@Override
	public void surfaceChanged(SurfaceHolder holder, int format, int width,
			int height) {

	}

	/**
	 * A valid barcode has been found, so give an indication of success and show
	 * the results.
	 * 
	 * @param rawResult
	 *            The contents of the barcode.
	 * @param barcode
	 *            A greyscale bitmap of the camera data which was decoded.
	 */
	public void handleDecode(Result rawResult, Bitmap barcode) {
		inactivityTimer.onActivity();
		lastResult = rawResult;
		/**
		 * Khanh Bui show dialog
		 */
		// initialDialogAttribute();
		// getDataResult();

		/******************
		 * Author : Toan Truong Thien Variable : checkBarCodeValuable Date
		 * create: 20-6-2013
		 * ****************/
		checkBarcodeValuable(lastResult.getText().toString());

		// dlgResult.show();
		// startActivity(new Intent(CaptureActivity.this, GetResultText.class)
		// .putExtra("Result", lastResult.getText().toString()));
		ResultHandler resultHandler = ResultHandlerFactory.makeResultHandler(
				this, rawResult);

		boolean fromLiveScan = barcode != null;
		if (fromLiveScan) {
			historyManager.addHistoryItem(rawResult, resultHandler);
			// Then not from history, so beep/vibrate and we have an image to
			// draw on
			beepManager.playBeepSoundAndVibrate();
			drawResultPoints(barcode, rawResult);
		}

		switch (source) {
		case NATIVE_APP_INTENT:
		case PRODUCT_SEARCH_LINK:
			handleDecodeExternally(rawResult, resultHandler, barcode);
			break;
		case ZXING_LINK:
			if (returnUrlTemplate == null) {
				handleDecodeInternally(rawResult, resultHandler, barcode);
			} else {
				handleDecodeExternally(rawResult, resultHandler, barcode);
			}
			break;
		case NONE:
			SharedPreferences prefs = PreferenceManager
					.getDefaultSharedPreferences(this);
			if (fromLiveScan
					&& prefs.getBoolean(PreferencesActivity.KEY_BULK_MODE,
							false)) {
				String message = getResources().getString(
						R.string.msg_bulk_mode_scanned)
						+ " (" + rawResult.getText() + ')';
				Toast.makeText(this, message, Toast.LENGTH_SHORT).show();
				// Wait a moment or else it will scan the same barcode
				// continuously about 3 times
				restartPreviewAfterDelay(BULK_MODE_SCAN_DELAY_MS);
			} else {
				handleDecodeInternally(rawResult, resultHandler, barcode);
			}
			break;
		}
	}

	private void checkBarcodeValuable(String strBarcode) {
		StringBuffer uri = new StringBuffer(
				"http://www.chimrawa.com/prints/checkoutWS?");
		uri.append("token=" + URLEncoder.encode(mStrToken) + "&code="
				+ URLEncoder.encode(strBarcode));
		Log.i("uri", uri.toString());
		String param[] = new String[2];
		param[0] = uri.toString();
		param[1] = "checkout";

		Authentication authentication = new Authentication(this);
		authentication.execute(param);
		try {
			handleInforResponse(authentication.get(), strBarcode);
		} catch (InterruptedException e) {
			Log.i("InterruptedException", e.getMessage());
		} catch (ExecutionException e) {
			Log.i("ExecutionException", e.getMessage());
		}
	}

	private void handleInforResponse(ContentValues content, String strBarcode) {
		Intent intent = new Intent(CaptureActivity.this,
				com.google.screen.Result.class);
		intent.putExtra("Token", mStrToken);
		intent.putExtra("barcode", strBarcode);
		intent.putExtra("code", content.getAsInteger("code"));
		intent.putExtra("message", content.getAsString("message"));
		if (content.getAsInteger("code") == -3
				|| content.getAsInteger("code") == 1) {
			intent.putExtra("coupon_id", content.getAsString("coupon_id"));
			intent.putExtra("category_id", content.getAsString("category_id"));
			intent.putExtra("title", content.getAsString("title"));
			intent.putExtra("description", content.getAsString("description"));
			intent.putExtra("image", content.getAsString("image"));
			intent.putExtra("nbr_to_print", content.getAsString("nbr_to_print"));
			intent.putExtra("nbr_printed", content.getAsString("nbr_printed"));
			intent.putExtra("start_date", content.getAsString("start_date"));
			intent.putExtra("end_date", content.getAsString("end_date"));
			intent.putExtra("status", content.getAsString("status"));
			intent.putExtra("checkout", content.getAsString("checkout"));
		}
		if (content.getAsInteger("code") == 1) {
			mDB.open();
			insertHistoryScanner(content, strBarcode);
			mDB.close();
		}
		startActivity(intent);
		finish();
	}

	private void insertHistoryScanner(ContentValues content, String strBarcode) {
		content.put("barcode", strBarcode);
		content.remove("statusheader");
		content.remove("code");
		content.remove("message");
		mDB.insertHistory(content);
	}

	private class DownloadImageTask extends AsyncTask<String, Void, Bitmap> {
		ImageView bmImage;

		public DownloadImageTask(ImageView bmImage) {
			this.bmImage = bmImage;
		}

		protected Bitmap doInBackground(String... urls) {
			String urldisplay = urls[0];
			Bitmap mIcon11 = null;
			try {
				InputStream in = new java.net.URL(urldisplay).openStream();
				mIcon11 = BitmapFactory.decodeStream(in);
			} catch (Exception e) {
				Log.e("Error", e.getMessage());
				e.printStackTrace();
			}
			return mIcon11;
		}

		protected void onPostExecute(Bitmap result) {
			bmImage.setImageBitmap(result);
		}
	}

	@Override
	public boolean onTouchEvent(MotionEvent event) {
		if (mRlayMenu.isShown()) {
			mRlayMenu.removeAllViews();
			mRlayMenu.setVisibility(View.GONE);
			mBlnMenu = false;
		}
		return super.onTouchEvent(event);
	}

	public void startScan(View v) {
		mRlayMenu.removeAllViews();
		mRlayMenu.setVisibility(View.GONE);
	}

	public void contact(View v) {
		Intent intent = new Intent(CaptureActivity.this, Contact.class);
		intent.putExtra("Token", mStrToken);
		startActivity(intent);
		finish();
	}

	public void logout(View v) {
		new Logout(this, mStrToken).execute();
	}

	public void parametres(View v) {
		mRlayMenu.removeAllViews();
		mRlayMenu.setVisibility(View.GONE);
	}

	public void viewFAQs(View v) {
		Intent intent = new Intent(CaptureActivity.this, FAQs.class);
		intent.putExtra("Token", mStrToken);
		startActivity(intent);
		finish();
	}

	public void viewControlHistory(View v) {
		Intent intent = new Intent(CaptureActivity.this, History.class);
		intent.putExtra("Token", mStrToken);
		startActivity(intent);
		finish();
	}

	public void setStringPref(SharedPreferences sharedPref, String name,
			String value) {
		SharedPreferences.Editor editor = sharedPref.edit();
		editor.putString(name, value);
		editor.commit();
	}

	public class Logout extends AsyncTask<String, Integer, String> {

		private Context mCtx;
		private ProgressDialog mProDialog;
		private String mStrToken;
		private Intent intent;

		public Logout(Context ctx, String strToken) {
			mCtx = ctx;
			mProDialog = new ProgressDialog(mCtx);
			mStrToken = strToken;
			intent = new Intent(mCtx, Login.class);
		}

		@Override
		protected String doInBackground(String... params) {
			setStringPref(mSharedPref, "token", "");
			StringBuffer uri = new StringBuffer(
					"http://www.chimrawa.com/service.php/authentication/logout?");
			uri.append("token=" + URLEncoder.encode(mStrToken));
			Log.i("uri", uri.toString());
			String param[] = new String[2];
			param[0] = uri.toString();
			param[1] = "logout";

			Authentication authentication = new Authentication(mCtx);
			authentication.execute(param);
			try {
				ContentValues data = authentication.get();
				if (data != null) {
					if (data.getAsInteger("code") == 1
							&& data.getAsString("statusheader").equals("ok")) {
						return "logout";
					} else {
						return "disconnect";
					}
				} else {
					return "notconnect";
				}
			} catch (InterruptedException e) {
				Log.i("InterruptedException", e.getMessage());
			} catch (ExecutionException e) {
				Log.i("ExecutionException", e.getMessage());
			}
			return null;
		}

		@Override
		protected void onPostExecute(String result) {
			mProDialog.dismiss();
			if (result.equals("logout")) {
				startActivity(intent);
				finish();
			}
			if (result.equals("disconnect")) {
				Toast.makeText(mCtx, "Can't disconnect!", Toast.LENGTH_SHORT)
						.show();
			}
			if (result.equals("notconnect")) {
				Toast.makeText(mCtx, "Can't connect to server!",
						Toast.LENGTH_SHORT).show();
			}
			super.onPostExecute(result);
		}

		@Override
		protected void onPreExecute() {
			mProDialog.setTitle("Logout Account");
			mProDialog.setMessage("Connecting...");
			mProDialog.setCancelable(false);
			mProDialog.setCanceledOnTouchOutside(false);
			mProDialog.show();
			super.onPreExecute();
		}

	}

	/**
	 * Superimpose a line for 1D or dots for 2D to highlight the key features of
	 * the barcode.
	 * 
	 * @param barcode
	 *            A bitmap of the captured image.
	 * @param rawResult
	 *            The decoded results which contains the points to draw.
	 */
	private void drawResultPoints(Bitmap barcode, Result rawResult) {
		ResultPoint[] points = rawResult.getResultPoints();
		if (points != null && points.length > 0) {
			Canvas canvas = new Canvas(barcode);
			Paint paint = new Paint();
			paint.setColor(getResources().getColor(R.color.result_points));
			if (points.length == 2) {
				paint.setStrokeWidth(4.0f);
				drawLine(canvas, paint, points[0], points[1]);
			} else if (points.length == 4
					&& (rawResult.getBarcodeFormat() == BarcodeFormat.UPC_A || rawResult
							.getBarcodeFormat() == BarcodeFormat.EAN_13)) {
				// Hacky special case -- draw two lines, for the barcode and
				// metadata
				drawLine(canvas, paint, points[0], points[1]);
				drawLine(canvas, paint, points[2], points[3]);
			} else {
				paint.setStrokeWidth(10.0f);
				for (ResultPoint point : points) {
					canvas.drawPoint(point.getX(), point.getY(), paint);
				}
			}
		}
	}

	private static void drawLine(Canvas canvas, Paint paint, ResultPoint a,
			ResultPoint b) {
		canvas.drawLine(a.getX(), a.getY(), b.getX(), b.getY(), paint);
	}

	// Put up our own UI for how to handle the decoded contents.
	private void handleDecodeInternally(Result rawResult,
			ResultHandler resultHandler, Bitmap barcode) {
		statusView.setVisibility(View.GONE);
		viewfinderView.setVisibility(View.GONE);
		resultView.setVisibility(View.GONE);

		popupResult.setVisibility(View.VISIBLE);

		ImageView barcodeImageView = (ImageView) findViewById(R.id.barcode_image_view);
		if (barcode == null) {
			barcodeImageView.setImageBitmap(BitmapFactory.decodeResource(
					getResources(), R.drawable.launcher_icon));
		} else {
			barcodeImageView.setImageBitmap(barcode);
		}

		TextView formatTextView = (TextView) findViewById(R.id.format_text_view);
		formatTextView.setText(rawResult.getBarcodeFormat().toString());

		TextView typeTextView = (TextView) findViewById(R.id.type_text_view);
		typeTextView.setText(resultHandler.getType().toString());

		DateFormat formatter = DateFormat.getDateTimeInstance(DateFormat.SHORT,
				DateFormat.SHORT);
		String formattedTime = formatter.format(new Date(rawResult
				.getTimestamp()));
		TextView timeTextView = (TextView) findViewById(R.id.time_text_view);
		timeTextView.setText(formattedTime);

		TextView metaTextView = (TextView) findViewById(R.id.meta_text_view);
		View metaTextViewLabel = findViewById(R.id.meta_text_view_label);
		metaTextView.setVisibility(View.GONE);
		metaTextViewLabel.setVisibility(View.GONE);
		Map<ResultMetadataType, Object> metadata = rawResult
				.getResultMetadata();
		if (metadata != null) {
			StringBuilder metadataText = new StringBuilder(20);
			for (Map.Entry<ResultMetadataType, Object> entry : metadata
					.entrySet()) {
				if (DISPLAYABLE_METADATA_TYPES.contains(entry.getKey())) {
					metadataText.append(entry.getValue()).append('\n');
				}
			}
			if (metadataText.length() > 0) {
				metadataText.setLength(metadataText.length() - 1);
				metaTextView.setText(metadataText);
				metaTextView.setVisibility(View.VISIBLE);
				metaTextViewLabel.setVisibility(View.VISIBLE);
			}
		}

		TextView contentsTextView = (TextView) findViewById(R.id.contents_text_view);
		CharSequence displayContents = resultHandler.getDisplayContents();
		contentsTextView.setText(displayContents);
		// Crudely scale betweeen 22 and 32 -- bigger font for shorter text
		int scaledSize = Math.max(22, 32 - displayContents.length() / 4);
		contentsTextView.setTextSize(TypedValue.COMPLEX_UNIT_SP, scaledSize);

		TextView supplementTextView = (TextView) findViewById(R.id.contents_supplement_text_view);
		supplementTextView.setText("");
		supplementTextView.setOnClickListener(null);
		if (PreferenceManager.getDefaultSharedPreferences(this).getBoolean(
				PreferencesActivity.KEY_SUPPLEMENTAL, true)) {
			SupplementalInfoRetriever.maybeInvokeRetrieval(supplementTextView,
					resultHandler.getResult(), historyManager, this);
		}

		int buttonCount = resultHandler.getButtonCount();
		ViewGroup buttonView = (ViewGroup) findViewById(R.id.result_button_view);
		buttonView.requestFocus();
		for (int x = 0; x < ResultHandler.MAX_BUTTON_COUNT; x++) {
			TextView button = (TextView) buttonView.getChildAt(x);
			if (x < buttonCount) {
				button.setVisibility(View.VISIBLE);
				button.setText(resultHandler.getButtonText(x));
				button.setOnClickListener(new ResultButtonListener(
						resultHandler, x));
			} else {
				button.setVisibility(View.GONE);
			}
		}

		if (copyToClipboard && !resultHandler.areContentsSecure()) {
			ClipboardManager clipboard = (ClipboardManager) getSystemService(CLIPBOARD_SERVICE);
			if (displayContents != null) {
				clipboard.setText(displayContents);
			}
		}
	}

	// Briefly show the contents of the barcode, then handle the result outside
	// Barcode Scanner.
	private void handleDecodeExternally(Result rawResult,
			ResultHandler resultHandler, Bitmap barcode) {

		if (barcode != null) {
			viewfinderView.drawResultBitmap(barcode);
		}

		long resultDurationMS;
		if (getIntent() == null) {
			resultDurationMS = DEFAULT_INTENT_RESULT_DURATION_MS;
		} else {
			resultDurationMS = getIntent().getLongExtra(
					Intents.Scan.RESULT_DISPLAY_DURATION_MS,
					DEFAULT_INTENT_RESULT_DURATION_MS);
		}

		// Since this message will only be shown for a second, just tell the
		// user what kind of
		// barcode was found (e.g. contact info) rather than the full contents,
		// which they won't
		// have time to read.
		if (resultDurationMS > 0) {
			statusView.setText(getString(resultHandler.getDisplayTitle()));
		}

		if (copyToClipboard && !resultHandler.areContentsSecure()) {
			ClipboardManager clipboard = (ClipboardManager) getSystemService(CLIPBOARD_SERVICE);
			CharSequence text = resultHandler.getDisplayContents();
			if (text != null) {
				clipboard.setText(text);
			}
		}

		if (source == IntentSource.NATIVE_APP_INTENT) {

			// Hand back whatever action they requested - this can be changed to
			// Intents.Scan.ACTION when
			// the deprecated intent is retired.
			Intent intent = new Intent(getIntent().getAction());
			intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET);
			intent.putExtra(Intents.Scan.RESULT, rawResult.toString());
			intent.putExtra(Intents.Scan.RESULT_FORMAT, rawResult
					.getBarcodeFormat().toString());
			byte[] rawBytes = rawResult.getRawBytes();
			if (rawBytes != null && rawBytes.length > 0) {
				intent.putExtra(Intents.Scan.RESULT_BYTES, rawBytes);
			}
			Map<ResultMetadataType, ?> metadata = rawResult.getResultMetadata();
			if (metadata != null) {
				if (metadata.containsKey(ResultMetadataType.UPC_EAN_EXTENSION)) {
					intent.putExtra(Intents.Scan.RESULT_UPC_EAN_EXTENSION,
							metadata.get(ResultMetadataType.UPC_EAN_EXTENSION)
									.toString());
				}
				Integer orientation = (Integer) metadata
						.get(ResultMetadataType.ORIENTATION);
				if (orientation != null) {
					intent.putExtra(Intents.Scan.RESULT_ORIENTATION,
							orientation.intValue());
				}
				String ecLevel = (String) metadata
						.get(ResultMetadataType.ERROR_CORRECTION_LEVEL);
				if (ecLevel != null) {
					intent.putExtra(Intents.Scan.RESULT_ERROR_CORRECTION_LEVEL,
							ecLevel);
				}
				Iterable<byte[]> byteSegments = (Iterable<byte[]>) metadata
						.get(ResultMetadataType.BYTE_SEGMENTS);
				if (byteSegments != null) {
					int i = 0;
					for (byte[] byteSegment : byteSegments) {
						intent.putExtra(
								Intents.Scan.RESULT_BYTE_SEGMENTS_PREFIX + i,
								byteSegment);
						i++;
					}
				}
			}
			sendReplyMessage(R.id.return_scan_result, intent, resultDurationMS);

		} else if (source == IntentSource.PRODUCT_SEARCH_LINK) {

			// Reformulate the URL which triggered us into a query, so that the
			// request goes to the same
			// TLD as the scan URL.
			int end = sourceUrl.lastIndexOf("/scan");
			String replyURL = sourceUrl.substring(0, end) + "?q="
					+ resultHandler.getDisplayContents() + "&source=zxing";
			sendReplyMessage(R.id.launch_product_query, replyURL,
					resultDurationMS);

		} else if (source == IntentSource.ZXING_LINK) {

			// Replace each occurrence of RETURN_CODE_PLACEHOLDER in the
			// returnUrlTemplate
			// with the scanned code. This allows both queries and REST-style
			// URLs to work.
			if (returnUrlTemplate != null) {
				CharSequence codeReplacement = returnRaw ? rawResult.getText()
						: resultHandler.getDisplayContents();
				try {
					codeReplacement = URLEncoder.encode(
							codeReplacement.toString(), "UTF-8");
				} catch (UnsupportedEncodingException e) {
					// can't happen; UTF-8 is always supported. Continue, I
					// guess, without encoding
				}
				String replyURL = returnUrlTemplate.replace(
						RETURN_CODE_PLACEHOLDER, codeReplacement);
				sendReplyMessage(R.id.launch_product_query, replyURL,
						resultDurationMS);
			}

		}
	}

	private void sendReplyMessage(int id, Object arg, long delayMS) {
		Message message = Message.obtain(handler, id, arg);
		if (delayMS > 0L) {
			handler.sendMessageDelayed(message, delayMS);
		} else {
			handler.sendMessage(message);
		}
	}

	/**
	 * We want the help screen to be shown automatically the first time a new
	 * version of the app is run. The easiest way to do this is to check
	 * android:versionCode from the manifest, and compare it to a value stored
	 * as a preference.
	 */
	private boolean showHelpOnFirstLaunch() {
		try {
			PackageInfo info = getPackageManager().getPackageInfo(PACKAGE_NAME,
					0);
			int currentVersion = info.versionCode;
			SharedPreferences prefs = PreferenceManager
					.getDefaultSharedPreferences(this);
			int lastVersion = prefs.getInt(
					PreferencesActivity.KEY_HELP_VERSION_SHOWN, 0);
			if (currentVersion > lastVersion) {
				prefs.edit()
						.putInt(PreferencesActivity.KEY_HELP_VERSION_SHOWN,
								currentVersion).commit();
				Intent intent = new Intent(this, HelpActivity.class);
				intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET);
				// Show the default page on a clean install, and the what's new
				// page on an upgrade.
				String page = lastVersion == 0 ? HelpActivity.DEFAULT_PAGE
						: HelpActivity.WHATS_NEW_PAGE;
				intent.putExtra(HelpActivity.REQUESTED_PAGE_KEY, page);
				startActivity(intent);
				return true;
			}
		} catch (PackageManager.NameNotFoundException e) {
			Log.w(TAG, e);
		}
		return false;
	}

	private void initCamera(SurfaceHolder surfaceHolder) {
		if (surfaceHolder == null) {
			throw new IllegalStateException("No SurfaceHolder provided");
		}
		if (cameraManager.isOpen()) {
			Log.w(TAG,
					"initCamera() while already open -- late SurfaceView callback?");
			return;
		}
		try {
			cameraManager.openDriver(surfaceHolder);
			// Creating the handler starts the preview, which can also throw a
			// RuntimeException.
			if (handler == null) {
				handler = new CaptureActivityHandler(this, decodeFormats,
						characterSet, cameraManager);
			}
			decodeOrStoreSavedBitmap(null, null);
		} catch (IOException ioe) {
			Log.w(TAG, ioe);
			displayFrameworkBugMessageAndExit();
		} catch (RuntimeException e) {
			// Barcode Scanner has seen crashes in the wild of this variety:
			// java.?lang.?RuntimeException: Fail to connect to camera service
			Log.w(TAG, "Unexpected error initializing camera", e);
			displayFrameworkBugMessageAndExit();
		}
	}

	private void displayFrameworkBugMessageAndExit() {
		AlertDialog.Builder builder = new AlertDialog.Builder(this);
		builder.setTitle(getString(R.string.app_name));
		builder.setMessage(getString(R.string.msg_camera_framework_bug));
		builder.setPositiveButton(R.string.button_ok, new FinishListener(this));
		builder.setOnCancelListener(new FinishListener(this));
		builder.show();
	}

	public void restartPreviewAfterDelay(long delayMS) {
		if (handler != null) {
			handler.sendEmptyMessageDelayed(R.id.restart_preview, delayMS);
		}
		resetStatusView();
	}

	private void resetStatusView() {
		resultView.setVisibility(View.GONE);
		popupResult.setVisibility(View.GONE);
		statusView.setText(R.string.msg_default_status);
		statusView.setVisibility(View.VISIBLE);
		viewfinderView.setVisibility(View.VISIBLE);
		lastResult = null;
	}

	public void drawViewfinder() {
		viewfinderView.drawViewfinder();
	}

	/******************
	 * Author : Khanh Bui Purpose :Initialise all item in dialog layout Date
	 * create: 25-1-2013
	 * ****************/

	public void initialDialogAttribute() {

		Log.i("In initialAttribute", "Passed");

		/********** POP-UP CONTENT ***********/
		// rltPopUpResult = (RelativeLayout) findViewById(R.id.rltPopUpResult);
		// set color for control warning pop up
		// rltPopUpResult.setBackgroundResource(drawable.bg_pop_up_small);
		// rltPopUpResult.setBackgroundColor(Color.GRAY);

		imgResult = (ImageView) findViewById(R.id.imgContent);
		// set text for title warning pop up
		imgResult.setBackgroundResource(R.drawable.test_img);

		txtTitle = (TextView) findViewById(R.id.txtTitle);
		// set text for content warning pop up
		txtTitle.setText("Result");
		txtTitle.setVisibility(View.VISIBLE);

		btnExitDialog = (Button) findViewById(R.id.btnExitDialog);
		// set img for button OK
		// btnExitDialog.setBackgroundResource(R.drawable.btn_restart);
		btnExitDialog.setText("Exit");
		btnExitDialog.setVisibility(View.GONE);
		btnExitDialog.setOnClickListener(new OnClickListener() {

			@Override
			public void onClick(View v) {
				// startActivity(new Intent(CaptureActivity.this,
				// CaptureActivity.class));
				Intent intent = getIntent();
				finish();
				startActivity(intent);
			}
		});

		btnPrevious = (Button) findViewById(R.id.btnPreResult);
		// set img for button Cancel
		// btnPrevious.setBackgroundResource(R.drawable.btn_restart);
		btnPrevious.setText("Previous");

		btnNext = (Button) findViewById(R.id.btnNextResult);
		// set img for button Cancel
		// btnPrevious.setBackgroundResource(R.drawable.btn_restart);
		btnNext.setText("Next");

		btnNext.setOnClickListener(new OnClickListener() {

			@Override
			public void onClick(View v) {

			}
		});

		btnURL = (Button) findViewById(R.id.btnURL);
		btnURL.setOnClickListener(new OnClickListener() {

			@Override
			public void onClick(View v) {
				// startActivity(new Intent(CaptureActivity.this,
				// GetResultText.class)
				// .putExtra("URL", strUrl));
				webURLContent.getSettings().setJavaScriptEnabled(true);
				webURLContent.setWebViewClient(new MyWebViewClient());
				webURLContent.loadUrl(strUrl);
				webURLContent.setVisibility(View.VISIBLE);
				btnBack.setVisibility(View.VISIBLE);
				popupResult.setVisibility(View.VISIBLE);

				btnURL.setVisibility(View.GONE);
				btnExitDialog.setVisibility(View.GONE);

			}
		});

		webURLContent = (WebView) findViewById(R.id.webShowURLContent);

		btnBack = (Button) findViewById(R.id.btnBack);
		btnBack.setOnClickListener(new OnClickListener() {

			@Override
			public void onClick(View v) {
				// webURLContent.clearView();
				webURLContent.loadUrl("about:blank");
				webURLContent.setVisibility(View.GONE);
				btnBack.setVisibility(View.GONE);

				btnURL.setVisibility(View.VISIBLE);
				btnExitDialog.setVisibility(View.VISIBLE);
				popupResult.setVisibility(View.VISIBLE);
			}
		});
		btnPrevious.setVisibility(View.GONE);
		btnNext.setVisibility(View.GONE);
		imgResult.setVisibility(View.GONE);
		txtTitle.setVisibility(View.GONE);
		btnURL.setVisibility(View.GONE);
	}

	/******************
	 * Author : Khanh Bui Purpose : Get data result from database xml file Date
	 * create: 25-1-2013
	 * ****************/
	public void getDataResult() {
		arrlstContQues = new ArrayList<ContentQuestions>();

		// arrlstContQues = new
		// Question(CaptureActivity.this).getArrlstContQues();

		String strCodeResult = lastResult.getText().toString();

		txtTitle.setText("Your bar code is :" + strCodeResult);
		txtTitle.setVisibility(View.VISIBLE);

		/*
		 * for (int i = 0; i < arrlstContQues.size(); i++) { Log.i("check arr",
		 * "string :"+strCodeResult); Log.i("check arr",
		 * "XML :"+arrlstContQues.get(i).getStrQues()); Log.i("check arr",
		 * "ansA :"+arrlstContQues.get(i).getStrAnsA()); if
		 * (strCodeResult.equals(arrlstContQues.get(i).getStrQues().toString())
		 * == true) {
		 * 
		 * int intResource =
		 * getResources().getIdentifier("drawable/"+arrlstContQues
		 * .get(i).getStrAnsA(), null, getPackageName());
		 * imgResult.setBackgroundResource(intResource); isValid = 1;
		 * 
		 * if (arrlstContQues.get(i).getStrAnsA().matches(".*pdf")) {
		 * strDownloadPDF = arrlstContQues.get(i).getStrAnsA();
		 * DownloadFilePDF(); btnPrevious.setVisibility(View.VISIBLE);
		 * btnNext.setVisibility(View.VISIBLE);
		 * imgResult.setVisibility(View.VISIBLE);
		 * txtTitle.setVisibility(View.VISIBLE); } else if
		 * (arrlstContQues.get(i).getStrAnsA().matches("http://.*")) { //
		 * Log.i("check URL", "is URL :"+arrlstContQues.get(i).getStrAnsA());
		 * 
		 * btnURL.setText("Click here to go to "+arrlstContQues.get(i).getStrAnsA
		 * ()); strUrl = arrlstContQues.get(i).getStrAnsA();
		 * btnURL.setVisibility(View.VISIBLE); } else {
		 * btnPrevious.setVisibility(View.VISIBLE);
		 * btnNext.setVisibility(View.VISIBLE);
		 * imgResult.setVisibility(View.VISIBLE);
		 * txtTitle.setVisibility(View.VISIBLE); } }
		 * 
		 * } if (isValid == 0) { txtTitle.setText("Your code is :"+strCodeResult
		 * +"\n"+"This code is not in database..."); }
		 */
	}

	/******************
	 * Author : Khanh Bui Purpose : Connect to server and get content of
	 * database xml file Date create: 28-1-2013
	 * ****************/
	class getContentXML extends AsyncTask<String, Integer, Void> {

		// Initialise executing variable URI
		HttpClient httpclient = new DefaultHttpClient();

		// Initialise variable for getting reponse from server
		org.apache.http.HttpResponse response;

		// url database file
		StringBuffer strURL = new StringBuffer(
				"http://www.goscom.vn/demo/reading_database.xml");

		@Override
		protected Void doInBackground(String... arg0) {
			if (isUpdateButton) {
				updateDatabase();
				isUpdateButton = false;
			} else {
				try {

					/**
					 * Khanh Bui Check data base file
					 * */
					File file = new File(
							"data/data/com.google.zxing.client.android/files/database.xml");
					Log.i("check file exist", file.exists() + "");
					Log.i("check file path", file.getPath() + "");

					/**
					 * Khanh Bui Get date modified of database file on server
					 * */
					// Create share file to save data modified of database
					sharedPref = getSharedPreferences("dateDBModified",
							Context.MODE_PRIVATE);

					// new getDateModified().execute();
					Log.i("get date modified before connect to server", ""
							+ dateModified);
					// connect to server
					StringBuffer strURL = new StringBuffer(
							"http://www.goscom.vn/demo/reading_database.xml");
					HttpURLConnection.setFollowRedirects(false);
					HttpURLConnection con;
					Log.i("In date modified", "OK");
					try {
						con = (HttpURLConnection) new URL(strURL.toString())
								.openConnection();
						// get date time modified
						dateModified = con.getLastModified();
						Log.i("What the fuck?", "" + dateModified);
					} catch (MalformedURLException e) {
						e.printStackTrace();
					} catch (IOException e) {
						e.printStackTrace();
					}
					// updateDatabase();
					Log.i("get date modified before check file", ""
							+ dateModified);

					/**
					 * Khanh Bui check condition to update new database
					 * */
					if (!file.exists()) {
						Log.i("file is not exist", "update database");
						updateDatabase();
					} else {
						Log.i("file is exist",
								"check date modifiled before update database");
						lastDateModified = sharedPref.getLong("date", -1);
						Log.i("check last file modified date", lastDateModified
								+ "");
						if (dateModified != lastDateModified) {
							Log.i("Update when diff time", lastDateModified
									+ "");
							updateDatabase();
						}
					}

				} catch (Exception e) {
					e.printStackTrace();
				}

			}
			return null;
		}

		/******************
		 * Author : Khanh Bui Purpose : Update database file and date time
		 * modified Date create: 29-1-2013
		 * ****************/
		public void updateDatabase() {
			// new getContentXML().execute();

			try {
				Log.i("check file modified date", dateModified + "");
				// Send request URI to server
				response = httpclient.execute(new HttpPost(strURL.toString()));
				// respose status [OK or not]
				StatusLine statusLine = response.getStatusLine();

				Log.i("update database", "OK");

				// check responding status
				if (statusLine.getStatusCode() == HttpStatus.SC_OK) {
					// response.getEntity().getContent();
					InputStream is = response.getEntity().getContent();

					FileOutputStream out = openFileOutput("database.xml",
							MODE_WORLD_WRITEABLE);
					int c;
					while ((c = is.read()) != -1) {
						// Log.i("check file modified date", c+"");
						out.write(c);
					}
					is.close();
					out.close();
				}
			} catch (Exception e) {

			}

			SharedPreferences.Editor editor = sharedPref.edit();
			editor.putLong("date", dateModified);
			editor.commit();
		}
	}

	private class MyWebViewClient extends WebViewClient {

		@Override
		public boolean shouldOverrideUrlLoading(WebView view, String url) {
			view.loadUrl(url);
			return false;
		}
	}

	/******************
	 * Author : Khanh Bui Purpose : Download file pdf with URL Date create:
	 * 29-1-2013
	 * ****************/

	public void DownloadFilePDF() {
		String extStorageDirectory = Environment.getExternalStorageDirectory()
				.toString();
		File folder = new File(extStorageDirectory, "pdf");
		folder.mkdir();
		File file = new File(folder, "Read.pdf");
		try {
			file.createNewFile();
		} catch (IOException e1) {
			e1.printStackTrace();
		}
		// Downloader.DownloadFile("http://www.goscom.vn/demo/test.pdf", file);
		Downloader.DownloadFile(strDownloadPDF, file);

		showPdf();
	}

	/******************
	 * Author : Khanh Bui Purpose : show pdf file with default reader pdf Date
	 * create: 29-1-2013
	 * ****************/

	public void showPdf() {
		File file = new File(Environment.getExternalStorageDirectory()
				+ "/pdf/Read.pdf");
		PackageManager packageManager = getPackageManager();
		Intent testIntent = new Intent(Intent.ACTION_VIEW);
		testIntent.setType("application/pdf");
		List list = packageManager.queryIntentActivities(testIntent,
				PackageManager.MATCH_DEFAULT_ONLY);
		Intent intent = new Intent();
		intent.setAction(Intent.ACTION_VIEW);
		Uri uri = Uri.fromFile(file);
		intent.setDataAndType(uri, "application/pdf");
		startActivity(intent);
	}

	@Override
	public void onBackPressed() {
		Intent intent = new Intent(CaptureActivity.this, Control.class);
		intent.putExtra("Token", mStrToken);
		startActivity(intent);
		finish();
	}

	/*******************************/

}
